Deep Learning

深度学习是机器学习研究中的一个新的领域，其动机在于建立、模拟人脑进行分析学习的神经网络，它模仿人脑的机制来解释数据，例如图像，声音和文本。

图解深度学习

目录

第1章　绪论
1.1　深度学习与机器学习　　2
1.2　深度学习的发展历程　　3
1.3　为什么是深度学习　　6
1.4　什么是深度学习　　7
1.5　本书结构　　9
第2章　神经网络
2.1　神经网络的历史　　12
2.2　M-P模型　　14
2.3　感知器　　16
2.4　多层感知器　　18
2.5　误差反向传播算法　　19
2.6　误差函数和激活函数　　28
2.7　似然函数　　30
2.8　随机梯度下降法　　31
2.9　学习率　　32
2.10　小结　　33
第3章　卷积神经网络
3.1　卷积神经网络的结构　　36
3.2　卷积层　　38
3.3　池化层　　39
3.4　全连接层　　40
3.5　输出层　　41
3.6　神经网络的训练方法　　41
3.7　小结　　48
第4章　受限玻尔兹曼机
4.1　Hopfield 神经网络　　50
4.2　玻尔兹曼机　　55
4.3　受限玻尔兹曼机　　59
4.4　对比散度算法　　61
4.5　深度信念网络　　64
4.6　小结　　66
第5章　自编码器
5.1　自编码器　　68
5.2　降噪自编码器　　71
5.3　稀疏自编码器　　73
5.4　栈式自编码器　　76
5.5　在预训练中的应用　　77
5.6　小结　　78
第6章　提高泛化能力的方法
6.1　训练样本　　80
6.2　预处理　　88
6.3　激活函数　　92
6.4　Dropout　　94
6.5　DropConnect　　96
6.6　小结　　98
第7章　深度学习工具
7.1　深度学习开发环境　　100
7.2　Theano　　100
7.3　Pylearn2　　108
7.4　Caffe　　118
7.5　训练系统——DIGITS137
7.6　Chainer　　145
7.7　TensorFlow　　160
7.8　小结　　176
第8章　深度学习的现在和未来
8.1　深度学习的应用案例178
8.2　深度学习的未来　　195
8.3　小结　　197
参考文献　　198
作者介绍　　207

白话深度学习与TensorFlow

Tensorflow：实战Google深度学习框架

目录

第1章 深度学习简介 1
1.1 人工智能、机器学习与深度学习 2
1.2 深度学习的发展历程 7
1.3 深度学习的应用 10
1.3.1 计算机视觉 10
1.3.2 语音识别 14
1.3.3 自然语言处理 15
1.3.4 人机博弈 18
1.4 深度学习工具介绍和对比 19
小结 23

第2章 TensorFlow环境搭建 25
2.1 TensorFlow的主要依赖包 25
2.1.1 Protocol Buffer 25
2.1.2 Bazel 27
2.2 TensorFlow安装 29
2.2.1 使用Docker安装 30
2.2.2 使用pip安装 32
2.2.3 从源代码编译安装 33
2.3 TensorFlow测试样例 37
小结 38

第3章 TensorFlow入门 40
3.1 TensorFlow计算模型——计算图 40
3.1.1 计算图的概念 40
3.1.2 计算图的使用 41
3.2 TensorFlow数据模型——张量 43
3.2.1 张量的概念 43
3.2.2 张量的使用 45
3.3 TensorFlow运行模型——会话 46
3.4 TensorFlow实现神经网络 48
3.4.1 TensorFlow游乐场及神经网络简介 48
3.4.2 前向传播算法简介 51
3.4.3 神经网络参数与TensorFlow变量 54
3.4.4 通过TensorFlow训练神经网络模型 58
3.4.5 完整神经网络样例程序 62
小结 65

第4章 深层神经网络 66
4.1 深度学习与深层神经网络 66
4.1.1 线性模型的局限性 67
4.1.2 激活函数实现去线性化 70
4.1.3 多层网络解决异或运算 73
4.2 损失函数定义 74
4.2.1 经典损失函数 75
4.2.2 自定义损失函数 79
4.3 神经网络优化算法 81
4.4 神经网络进一步优化 84
4.4.1 学习率的设置 85
4.4.2 过拟合问题 87
4.4.3 滑动平均模型 90
小结 92

第5章 MNIST数字识别问题 94
5.1 MNIST数据处理 94
5.2 神经网络模型训练及不同模型结果对比 97
5.2.1 TensorFlow训练神经网络 97
5.2.2 使用验证数据集判断模型效果 102
5.2.3 不同模型效果比较 103
5.3 变量管理 107
5.4 TensorFlow模型持久化 112
5.4.1 持久化代码实现 112
5.4.2 持久化原理及数据格式 117
5.5 TensorFlow最佳实践样例程序 126
小结 132

第6章 图像识别与卷积神经网络 134
6.1 图像识别问题简介及经典数据集 135
6.2 卷积神经网络简介 139
6.3 卷积神经网络常用结构 142
6.3.1 卷积层 142
6.3.2 池化层 147
6.4 经典卷积网络模型 149
6.4.1 LeNet-5模型 150
6.4.2 Inception-v3模型 156
6.5 卷积神经网络迁移学习 160
6.5.1 迁移学习介绍 160
6.5.2 TensorFlow实现迁移学习 161
小结 169

第7章 图像数据处理 170
7.1 TFRecord输入数据格式 170
7.1.1 TFRecord格式介绍 171
7.1.2 TFRecord样例程序 171
7.2 图像数据处理 173
7.2.1 TensorFlow图像处理函数 174
7.2.2 图像预处理完整样例 183
7.3 多线程输入数据处理框架 185
7.3.1 队列与多线程 186
7.3.2 输入文件队列 190
7.3.3 组合训练数据（batching） 193
7.3.4 输入数据处理框架 196
小结 198

第8章 循环神经网络 200
8.1 循环神经网络简介 200
8.2 长短时记忆网络（LTSM）结构 206
8.3 循环神经网络的变种 212
8.3.1 双向循环神经网络和深层循环神经网络 212
8.3.2 循环神经网络的dropout 214
8.4 循环神经网络样例应用 215
8.4.1 自然语言建模 216
8.4.2 时间序列预测 225
小结 230

第9章 TensorBoard可视化 232
9.1 TensorBoard简介 232
9.2 TensorFlow计算图可视化 234
9.2.1 命名空间与TensorBoard图上节点 234
9.2.2 节点信息 241
9.3 监控指标可视化 246
小结 252

第10章 TensorFlow计算加速 253
10.1 TensorFlow使用GPU 253
10.2 深度学习训练并行模式 258
10.3 多GPU并行 261
10.4 分布式TensorFlow 268
10.4.1 分布式TensorFlow原理 269
10.4.2 分布式TensorFlow模型训练 272
10.4.3 使用Caicloud运行分布式TensorFlow 282
小结 287

解析深度学习：语音识别实践

深度学习是机器学习中一种基于对数据进行表征学习的方法。观测值（例如一幅图像）可以使用多种方式来表示，如每个像素强度值的向量，或者更抽象地表示成一系列边、特定形状的区域等。而使用某些特定的表示方法更容易从实例中学习任务（例如，人脸识别或面部表情识别）。深度学习的好处是用非监督式或半监督式的特征学习和分层特征提取高效算法来替代手工获取特征。

同机器学习方法一样，深度机器学习方法也有监督学习与无监督学习之分．不同的学习框架下建立的学习模型很是不同．例如，卷积神经网络（Convolutional neural networks，简称CNNs）就是一种深度的监督学习下的机器学习模型，而深度置信网（Deep Belief Nets，简称DBNs）就是一种无监督学习下的机器学习模型。

卷积神经网络(Convolutional Neural Network, CNN)

递归神经网络(Recursive Neural Network, RNN)

强化学习(Reinforcement Learning)

10 个基于 JavaScript 的机器学习实例

随着人工智能技术的发展，机器学习越来越受到开发者们的关注，从而也导致了机器学习库如雨后春笋般的涌现出来，而且没有任何放缓的趋势。虽然，传统意义上 Python 已经成为了最受欢迎的机器学习语言。但目前神经网络可在任何编程语言中运行，当然也包括 JavaScript！

近来，Web 生态系统取得了重大的进展。尽管 JavaScript 和 Node.js 的性能要比 Python 和 Java 的性能差，但它们已经能够应对机器学习中的许多问题。同时，Web 编程语言也具有很强的易用性，即你只要搞定了 Web 浏览器，那么运行 JavaScript ML 项目就不是个事儿。

虽然，大多数 JavaScript 机器学习库都是“新轮子”，有的甚至还在研发中，但并不会影响你的使用。在这篇文章中，我们将与你分享这些库，以及一些很酷的 AI Web 应用程序实例，帮助你开启机器学习之旅。

1. Brain

Brain 是一个可以让你轻松创建神经网络的库，并可通过输入/输出数据进行训练。尽管，它可以直接在浏览器网页上运行，但是训练的过程会占用大量的资源，因此最好在 Node.js 环境中启动它。另外，在他们网站上还有一个用于训练识别色彩对比度的小例子，你也可以了解下。
项目地址：【传送门】

2. Deep playground

这是由 TensorFlow 出品的可视化的神经网络交互式学习程序。它可以带你了解神经网络，并探索其不同的组件。它不仅有一个漂亮的用户界面，而且通过控制数据、神经元数量、使用算法的类别以及各项其他的指标，让你能够直观、实时的了解其运行的状态。另外，由于它是开源的（它用 TypeScript 编写，并具备优质的文档可查阅），所以通过了解其项目背景，你还能够学到更多有价值的知识。
项目地址：【传送门】

3. FlappyLearning

FlappyLearning 是一个仅用 800 行代码创建的 JavaScript 机器学习库，它让你可以像行家一样玩转 Flappy Bird 游戏。在这个库中所使用的 AI 技术被称为“Neuroevolution”，而它所应用算法的灵感则源于自然界生物神经系统的进化，并且它可以从每次成功或失败的迭代中进行动态的学习。另外，你只需要在浏览器中打开 index.html 就可以运行它了，炒鸡简单。
项目地址：【传送门】

4. Synaptic

这个项目可能是本文所有项目中最活跃的项目了。Synaptic 是一个 Node.js 和浏览器可用的库。虽然它的架构未知，但开发人员可以通过它来构建任何类型的神经网络。它也具备一些内置架构，使它能够快速的测试，并能针对不同的机器学习算法进行比较。同时，它的使用文档丰富且全面，包含了神经网络的基本介绍、一些实用的演示，以及相应的使用教程。
项目地址：【传送门】

5. Land Lines

Land Lines 是一个有趣的 Chrome Web 实验。用户通过在页面上涂鸦，来发现地球上的卫星图像。它可以完全在浏览器中运行，无需服务器端的调用。同时，由于机器学习和 WebGL 的巧妙使用，即使在移动设备上它也有出色的表现。如果你对它比较感兴趣，也可以在 GitHub 上查看其源码，或者在这里阅读整个案例研究。
项目地址：【传送门】

6. ConvNetJS

虽然，此项目不再积极维护，但 ConvNetJS 却是基于 JavaScript 最先进的深度学习库之一。最初它是由斯坦福大学开发的项目，随着在 GitHub 上的流行，许多社区开始驱动了其新的特性，并撰写了相关的教程。它可以直接在浏览器中工作，支持多种学习技术，而且操作简单，适合神经网络进阶者学习。
项目地址：【传送门】

7. Thing Translator

Thing Translator 是一个 Web 实验，让你可以通过手机来识别实物，并可用不同的语言为它们命名。这款应用程序完全基于 Web 技术构建，并整合了 Google 的两种机器学习 API，即用于图像识别的 Cloud Vision 和用于自然语言翻译的 Translate API 。
项目地址：【传送门】

8. Neurojs

这是一个基于强化学习的人工智能系统框架。遗憾的是，这个开源项目并没有合适的文档。但其中一个自动驾驶汽车的演示，却对组成神经网络的不同部分有很好的描述。这个库仅通过 JavaScript 实现，并应用了 webpack 和 babel 。
项目地址：【传送门】

9. Machine_learning

Machine_learning 是一个仅通过 JavaScript 便可设置和训练神经网络的库。无论是在 Node.js，还是客户端上，它都易于安装，并且具备非常干净的 API，适合任何技术级别的开发者进行学习。同时，该库还提供了许多现成的流行算法示例，帮助你了解核心的机器学习原理。
项目地址：【传送门】

Logistic Regression
var ml = require('machine_learning');
var x = [[1,1,1,0,0,0],
     [1,0,1,0,0,0],
     [1,1,1,0,0,0],
     [0,0,1,1,1,0],
     [0,0,1,1,0,0],
     [0,0,1,1,1,0]];
var y = [[1, 0],
     [1, 0],
     [1, 0],
     [0, 1],
     [0, 1],
     [0, 1]];

var classifier = new ml.LogisticRegression({
'input' : x,
'label' : y,
'n_in' : 6,
'n_out' : 2
});

classifier.set('log level',1);

var training_epochs = 800, lr = 0.01;

classifier.train({
'lr' : lr,
'epochs' : training_epochs
});

x = [[1, 1, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 0],
 [1, 1, 1, 1, 1, 0]];

console.log("Result : ",classifier.predict(x));
MLP (Multi-Layer Perceptron)
var ml = require('machine_learning');
var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
     [0.5, 0.3,  0.5, 0.,  0.,  0.],
     [0.4, 0.5, 0.5, 0.,  0.,  0.],
     [0.,  0.,  0.5, 0.3, 0.5, 0.],
     [0.,  0.,  0.5, 0.4, 0.5, 0.],
     [0.,  0.,  0.5, 0.5, 0.5, 0.]];
var y = [[1, 0],
     [1, 0],
     [1, 0],
     [0, 1],
     [0, 1],
     [0, 1]];

var mlp = new ml.MLP({
'input' : x,
'label' : y,
'n_ins' : 6,
'n_outs' : 2,
'hidden_layer_sizes' : [4,4,5]
});

mlp.set('log level',1); // 0 : nothing, 1 : info, 2 : warning.

mlp.train({
'lr' : 0.6,
'epochs' : 20000
});

a = [[0.5, 0.5, 0., 0., 0., 0.],
 [0., 0., 0., 0.5, 0.5, 0.],
 [0.5, 0.5, 0.5, 0.5, 0.5, 0.]];

console.log(mlp.predict(a));
SVM (Support Vector Machine)
var ml = require('machine_learning');
var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
     [0.5, 0.3,  0.5, 0.,  0.,  0.01],
     [0.4, 0.8, 0.5, 0.,  0.1,  0.2],
     [1.4, 0.5, 0.5, 0.,  0.,  0.],
     [1.5, 0.3,  0.5, 0.,  0.,  0.],
     [0., 0.9, 1.5, 0.,  0.,  0.],
     [0., 0.7, 1.5, 0.,  0.,  0.],
     [0.5, 0.1,  0.9, 0.,  -1.8,  0.],
     [0.8, 0.8, 0.5, 0.,  0.,  0.],
     [0.,  0.9,  0.5, 0.3, 0.5, 0.2],
     [0.,  0.,  0.5, 0.4, 0.5, 0.],
     [0.,  0.,  0.5, 0.5, 0.5, 0.],
     [0.3, 0.6, 0.7, 1.7,  1.3, -0.7],
     [0.,  0.,  0.5, 0.3, 0.5, 0.2],
     [0.,  0.,  0.5, 0.4, 0.5, 0.1],
     [0.,  0.,  0.5, 0.5, 0.5, 0.01],
     [0.2, 0.01, 0.5, 0.,  0.,  0.9],
     [0.,  0.,  0.5, 0.3, 0.5, -2.3],
     [0.,  0.,  0.5, 0.4, 0.5, 4],
     [0.,  0.,  0.5, 0.5, 0.5, -2]];

var y =  [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1];

var svm = new ml.SVM({
x : x,
y : y
});

svm.train({
C : 1.1, // default : 1.0. C in SVM.
tol : 1e-5, // default : 1e-4. Higher tolerance --> Higher precision
max_passes : 20, // default : 20. Higher max_passes --> Higher precision
alpha_tol : 1e-5, // default : 1e-5. Higher alpha_tolerance --> Higher precision

kernel : { type: "polynomial", c: 1, d: 5}
// default : {type : "gaussian", sigma : 1.0}
// {type : "gaussian", sigma : 0.5}
// {type : "linear"} // x*y
// {type : "polynomial", c : 1, d : 8} // (x*y + c)^d
// Or you can use your own kernel.
// kernel : function(vecx,vecy) { return dot(vecx,vecy);}
});

console.log("Predict : ",svm.predict([1.3,  1.7,  0.5, 0.5, 1.5, 0.4]));
KNN (K-nearest neighbors)
var ml = require('machine_learning');

var data = [[1,0,1,0,1,1,1,0,0,0,0,0,1,0],
        [1,1,1,1,1,1,1,0,0,0,0,0,1,0],
        [1,1,1,0,1,1,1,0,1,0,0,0,1,0],
        [1,0,1,1,1,1,1,1,0,0,0,0,1,0],
        [1,1,1,1,1,1,1,0,0,0,0,0,1,1],
        [0,0,1,0,0,1,0,0,1,0,1,1,1,0],
        [0,0,0,0,0,0,1,1,1,0,1,1,1,0],
        [0,0,0,0,0,1,1,1,0,1,0,1,1,0],
        [0,0,1,0,1,0,1,1,1,1,0,1,1,1],
        [0,0,0,0,0,0,1,1,1,1,1,1,1,1],
        [1,0,1,0,0,1,1,1,1,1,0,0,1,0]
       ];

var result = [23,12,23,23,45,70,123,73,146,158,64];

var knn = new ml.KNN({
data : data,
result : result
});

var y = knn.predict({
x : [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
k : 3,

weightf : {type : 'gaussian', sigma : 10.0},
// default : {type : 'gaussian', sigma : 10.0}
// {type : 'none'}. weight == 1
// Or you can use your own weight f
// weightf : function(distance) {return 1./distance}

distance : {type : 'euclidean'}
// default : {type : 'euclidean'}
// {type : 'pearson'}
// Or you can use your own distance function
// distance : function(vecx, vecy) {return Math.abs(dot(vecx,vecy));}
});

console.log(y);
K-means clustering
var ml = require('machine_learning');

var data = [[1,0,1,0,1,1,1,0,0,0,0,0,1,0],
        [1,1,1,1,1,1,1,0,0,0,0,0,1,0],
        [1,1,1,0,1,1,1,0,1,0,0,0,1,0],
        [1,0,1,1,1,1,1,1,0,0,0,0,1,0],
        [1,1,1,1,1,1,1,0,0,0,0,0,1,1],
        [0,0,1,0,0,1,0,0,1,0,1,1,1,0],
        [0,0,0,0,0,0,1,1,1,0,1,1,1,0],
        [0,0,0,0,0,1,1,1,0,1,0,1,1,0],
        [0,0,1,0,1,0,1,1,1,1,0,1,1,1],
        [0,0,0,0,0,0,1,1,1,1,1,1,1,1],
        [1,0,1,0,0,1,1,1,1,1,0,0,1,0]
       ];

var result = ml.kmeans.cluster({
data : data,
k : 4,
epochs: 100,

distance : {type : "pearson"}
// default : {type : 'euclidean'}
// {type : 'pearson'}
// Or you can use your own distance function
// distance : function(vecx, vecy) {return Math.abs(dot(vecx,vecy));}
});

console.log("clusters : ", result.clusters);
console.log("means : ", result.means);
Hill-Climbing
var ml = require('machine_learning');

var costf = function(vec) {
var cost = 0;
for(var i =0; i<14;i++) { // 15-dimensional vector
    cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
}
cost += (3.*vec[14]/vec[0]);
return cost;
};

var domain = [];
for(var i=0;i<15;i++)
domain.push([1,70]); // domain[idx][0] : minimum of vec[idx], domain[idx][1] : maximum of vec[idx].

var vec = ml.optimize.hillclimb({
domain : domain,
costf : costf
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));
Simulated Annealing
var ml = require('machine_learning');

var costf = function(vec) {
var cost = 0;
for(var i =0; i<14;i++) { // 15-dimensional vector
    cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
}
cost += (3.*vec[14]/vec[0]);
return cost;
};

var domain = [];
for(var i=0;i<15;i++)
domain.push([1,70]); // domain[idx][0] : minimum of vec[idx], domain[idx][1] : maximum of vec[idx].

var vec = ml.optimize.anneal({
domain : domain,
costf : costf,
temperature : 100000.0,
cool : 0.999,
step : 4
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));
Genetic Algorithm
var ml = require('machine_learning');

var costf = function(vec) {
var cost = 0;
for(var i =0; i<14;i++) { // 15-dimensional vector
    cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
}
cost += (3.*vec[14]/vec[0]);
return cost;
};

var domain = [];
for(var i=0;i<15;i++)
domain.push([1,70]); // domain[idx][0] : minimum of vec[idx], domain[idx][1] : maximum of vec[idx].

var vec = ml.optimize.genetic({
domain : domain,
costf : costf,
population : 50,
elite : 2, // elitism. number of elite chromosomes.
epochs : 300,
q : 0.3 // Rank-Based Fitness Assignment. fitness = q * (1-q)^(rank-1)
        // higher q --> higher selection pressure
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));
Decision Tree
// Reference : 'Programming Collective Intellignece' by Toby Segaran.

var ml = require('machine_learning');

var data =[['slashdot','USA','yes',18],
       ['google','France','yes',23],
       ['digg','USA','yes',24],
       ['kiwitobes','France','yes',23],
       ['google','UK','no',21],
       ['(direct)','New Zealand','no',12],
       ['(direct)','UK','no',21],
       ['google','USA','no',24],
       ['slashdot','France','yes',19],
       ['digg','USA','no',18,],
       ['google','UK','no',18,],
       ['kiwitobes','UK','no',19],
       ['digg','New Zealand','yes',12],
       ['slashdot','UK','no',21],
       ['google','UK','yes',18],
       ['kiwitobes','France','yes',19]];
var result = ['None','Premium','Basic','Basic','Premium','None','Basic','Premium','None','None','None','None','Basic','None','Basic','Basic'];

var dt = new ml.DecisionTree({
data : data,
result : result
});

dt.build();

// dt.print();

console.log("Classify : ", dt.classify(['(direct)','USA','yes',5]));

dt.prune(1.0); // 1.0 : mingain.
dt.print();
NMF (Non-negative matrix factorization)
var ml = require('machine_learning');
var matrix = [[22,28],
          [49,64]];

var result = ml.nmf.factorize({
matrix : matrix,
features : 3,
epochs : 100
});

console.log("First Matrix : ",result[0]);
console.log("Second Matrix : ",result[1]);

10. DeepForge

DeepForge 是一个对于用户友好的深度学习开发环境。有了它，你可以使用简单的图形界面对神经网络进行设计，同时它还支持远程机器的训练模型，并且内置了版本控制。它基于 Node.js 和 MongoDB，可在浏览器中运行。对于大多数 Web 开发者来说，它的安装过程也会相当的简单。
项目地址：【传送门】

奖励：Machine Learning in Javascript

这是由 Burak Kanber 发表的一系列文章，主要介绍了一些机器学习基础知识。这些教程专门针对 JavaScript 开发人员，而且写得比较透彻。如果你想更深入地了解机器学习，不妨看一看。
结论
虽然，基于 JavaScript 的机器学习生态体系还在不断的发展，但本文推荐的这些资源，能够帮助你开启机器学习的体验之旅，并对其核心技术有所了解。正如文章中的实例所示，你只需通过浏览器和一些熟知的 JavaScript 代码就能体会到机器学习的极大乐趣。